#ifndef _THREAD_HPP_
#define _THREAD_HPP_

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>

namespace mythread
{
    int number = 1;
    class thread
    {
    public:
        thread():_detach(false)
                ,_running(false)
                ,_tid(0)
        {
            _name = "thread-" + std::to_string(number++); //std::to_string(number++); 将数值转换为字符串
        }

        void EnableRunning()
        {
            std::cout << "线程标志位开启" << std::endl;
            _running = true;
        }

        //线程分离
        void EnableDetach()
        {
            std::cout << "线程分离" << std::endl;
            _detach = true;
        }

        //需要加static修饰，因为类函数有隐式指针this,如果不添加static那么会有两个参数。
        //添加static之后，这个类函数就是全局的，也就不会与某个对象关联，也便没有了this指针
        //这时候不可以调用类里边的成员；
        //可以通过pthread_create进行属性的传参 -> 将this指针传过来，然后将接收到的this指针强转成thread
        static void* routine(void* agrs)    
        {
            thread* self = static_cast<thread *>(agrs);

            //这里不加判断，因为标志位重复标志也不会有影响
            self->EnableRunning();  //线程启动标志位
            //self->EnableDetach();   //线程分离标志位
            //这里可以回调函数，执行线程操作
            int cnt = 10;
            while(cnt--)
            {
                std::cout << "线程运行: " << self->_name << std::endl; 
                sleep(1);
            }
            return nullptr;
        }

        //线程开始
        bool Start()
        {
            if(_running)
                return false;
            
            int n = pthread_create(&_tid,nullptr,routine,this);
            if(n != 0)
            {
                std::cout << "线程创建失败" << std::endl;
                return false;
            }
            else
            {
                std::cout << "线程创建成功" << std::endl;
                return true;
            }
        }

        //线程停止
        bool Stop()
        {
            if(_running)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                {
                    std::cout << "线程Stop失败" << std::endl;
                    return false;
                }
                else
                {
                    std::cout << "线程Stop成功 -> " << _name << std::endl;
                    return true;
                }
            }
            std::cout << "线程未启动" << std::endl;
            return false;
        }

        //线程回收
        bool Join()
        {
            if(_detach)
            {
                std::cout << "线程已分离,不需要join" <<std::endl;
                return true;
            }
            else
            {
                int n = pthread_join(_tid,nullptr);
                if(n != 0)
                {
                    std::cout << "线程join失败" << std::endl;
                    return false;
                }
                else
                {
                    std::cout << "线程join成功 -> " << _name << std::endl;
                    return true;
                }

            }
        }


    private:
        std::string _name;
        bool _detach;   //线程分离标志位
        bool _running;  //线程是否启动
        pthread_t _tid; //线程id

    };
}




#endif

